import Vue from "vue";
import { Notification } from "element-ui";
const moment = require("moment");
const _ = require("lodash");
const Key = "PY-Dict"; // LocalStorage中键值

export default class Dictionary {
    constructor () {
        this.list = {}; // 字典列表
        this.updateAt = ""; // 本地最后更新时间

        this.initDict();
    }

    /* 初始化字典类 */
    initDict () {
        const raw = localStorage.getItem(Key);
        if (raw) {
            const dict = JSON.parse(raw);
            // 如果 updateAt 存在且与现在相差 ≤ 1 天，直接复用
            if (dict.updateAt && moment().diff(moment(dict.updateAt), "days") <= 1) {
                _.assign(this, dict);
                return;
            }
        }
        // 不存在或已过期 → 重新拉取并缓存
        this.updateDict();
    }

    /* 通过接口设置某个字典值 */
    async setDictByApi (code) {
        if (!code) {
            Notification.error({ title: "错误", message: "Dictionary: 无法解析设置字典的code" });
            return;
        }
        const params = {
            dictTypeId: code,
            page: 1,
            pageSize: 10000
        };
        return Vue.prototype.$request.post(Vue.prototype.API.GET_DICT_LIST, params).then(res => {
            if (res.success) {
                /* 转化为特定格式 */
                let list = res.data.data.map(i => {
                    return {
                        label: i.dictLabel,
                        value: i.dictValue,
                        code: i.dictDataId,
                        status: i.status,
                        order: i.dictSort
                    };
                });

                /* 移除禁用项 */
                list = list.filter(i => {
                    return i.status === 1;
                });

                /* 排序 */
                list.sort((a, b) => {
                    return a.order - b.order;
                });
                this.options = list;

                /* 存入localStorage */
                this.setDict(code, list);
                return list;
            }
        });
    }

    /* 设置某个字典列表 */
    setDict (code, list) {
        if (!code) {
            Notification.error({ title: "错误", message: "Dictionary: 无法解析设置字典的code" });
            return;
        }
        this.list[code] = list;
        this.updateDict();
    }

    /* 更新LocalStorage中的字典 */
    updateDict () {
        const params = {
            list: this.list,
            updateAt: moment().format("YYYY-MM-DD HH:mm:ss")
        };
        localStorage.setItem(Key, JSON.stringify(params));
    }

    /* 获取字典的列表，如果在本地存储中没有获取到对应的字典code值，则重新请求接口 */
    getDict (code) {
        if (!this.list[code]) return this.setDictByApi(code);
        return new Promise((resolve) => {
            resolve(this.list[code]);
        });
    }

    /* 根据字典值的实际值，获取字典值的显示值 */
    getDictLabel (code, value) {
        if (!this.list[code]) {
            this.setDictByApi(code).then(res => {
                if (res) this.getDictLabel(code, value);
            });
        }
        else {
            const match = this.list[code].find(i => {
                return i.value == value;
            });
            if (match) return match.label;
            else return "";
        }
    }
    /* 根据字典值的显示值，获取字典值的实际值 */
    getDictValue (code, label) {}

    /* 删除某个字典值 */
    deleteDict (code) {
        if (!code) {
            Notification.error({ title: "错误", message: "Dictionary: 无法解析删除字典的code" });
            return;
        }
        delete this.list[code];
        this.updateDict();
    }

    /* 清空本地所有字典 */
    clearAllDict () {
        for (let key in this.list) this.deleteDict(key);
    }
}